import axios from 'axios'
import { ElMessage } from 'element-plus'
import router from '@/router'

// 创建 axios 实例
const api = axios.create({
  baseURL: 'http://localhost:8080/api', // 使用完整的后端地址
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    return config
  },
  error => {
    console.error('Request error:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 如果是正常的响应数据
    if (response.data && typeof response.data === 'object') {
      return response.data
    }
    
    // 如果是字符串响应，尝试解析
    if (typeof response.data === 'string') {
      try {
        // 尝试直接解析完整的 JSON
        return JSON.parse(response.data)
      } catch (e) {
        console.error('完整 JSON 解析失败，尝试提取数据部分')
        try {
          // 提取第一个完整的 JSON 对象
          const jsonStart = response.data.indexOf('{')
          if (jsonStart !== -1) {
            let bracketCount = 0
            let jsonEnd = jsonStart
            
            for (let i = jsonStart; i < response.data.length; i++) {
              if (response.data[i] === '{') bracketCount++
              if (response.data[i] === '}') bracketCount--
              if (bracketCount === 0) {
                jsonEnd = i + 1
                break
              }
            }
            
            if (jsonEnd > jsonStart) {
              const jsonStr = response.data.substring(jsonStart, jsonEnd)
              const result = JSON.parse(jsonStr)
              if (result.data && Array.isArray(result.data)) {
                return result
              }
            }
          }
        } catch (e2) {
          console.error('提取数据解析失败:', e2)
        }
      }
    }
    return response.data
  },
  error => {
    console.error('Response error:', error)
    
    // 处理错误响应中的数据
    if (error.response?.data) {
      const errorData = error.response.data
      if (typeof errorData === 'string') {
        try {
          // 提取第一个完整的 JSON 对象
          const jsonStart = errorData.indexOf('{')
          if (jsonStart !== -1) {
            let bracketCount = 0
            let jsonEnd = jsonStart
            
            for (let i = jsonStart; i < errorData.length; i++) {
              if (errorData[i] === '{') bracketCount++
              if (errorData[i] === '}') bracketCount--
              if (bracketCount === 0) {
                jsonEnd = i + 1
                break
              }
            }
            
            if (jsonEnd > jsonStart) {
              const jsonStr = errorData.substring(jsonStart, jsonEnd)
              const result = JSON.parse(jsonStr)
              if (result.data && Array.isArray(result.data)) {
                return Promise.resolve(result)
              }
            }
          }
        } catch (e) {
          console.error('错误响应数据解析失败:', e)
        }
      }
    }
    
    // 错误处理
    if (error.response) {
      switch (error.response.status) {
        case 401:
          localStorage.removeItem('token')
          router.push('/login')
          ElMessage.error('登录已过期，请重新登录')
          break
        case 403:
          ElMessage.error('没有权限访问该资源')
          break
        case 500:
          // 不显示通用的500错误，因为可能包含有效数据
          console.warn('服务器返回500错误，但可能包含有效数据')
          break
        default:
          ElMessage.error(error.response.data?.message || '请求失败')
      }
    } else {
      ElMessage.error('网络错误，请检查网络连接')
    }
    return Promise.reject(error)
  }
)

// 用户认证相关
export const login = (username, password) => {
  return api.post('/auth/login', { 
    username, 
    password 
  })
}

export const register = (data) => {
  return api.post('/auth/register', data)
}

// 土壤监测数据相关
export const getSoilTemperatureData = (start, end) => {
  return api.get('/soil-temperature-data', {
    params: { start, end }
  })
}

export const getPhData = (start, end) => {
  return api.get('/ph-data', {
    params: { start, end }
  })
}

export const getPhosphorusData = (start, end) => {
  return api.get('/phosphorus-data', {
    params: { start, end }
  })
}

export const getPotassiumData = (start, end) => {
  return api.get('/potassium-data', {
    params: { start, end }
  })
}

export const getLightData = (start, end) => {
  return api.get('/light-data', {
    params: { start, end }
  })
}

// 手动触发数据采集
export const collectAllSoilData = async (greenhouseId) => {
  try {
    // 并行调用所有采集接口
    const [tempResponse, phResponse, phosphorusResponse, potassiumResponse, lightResponse] = await Promise.all([
      api.post('/soil-temperature-data/collect'),
      api.post('/ph-data/collect'),
      api.post('/phosphorus-data/collect'),
      api.post('/potassium-data/collect'),
      api.post('/light-data/collect')
    ])
    
    // 等待1秒让数据写入数据库
    await new Promise(resolve => setTimeout(resolve, 1000))
    
    // 获取最新数据
    const end = new Date()
    const start = new Date(end - 5 * 60 * 1000) // 最近5分钟的数据
    
    const [tempData, phData, phosphorusData, potassiumData, lightData] = await Promise.all([
      api.get('/soil-temperature-data', { params: { start: start.getTime(), end: end.getTime() }}),
      api.get('/ph-data', { params: { start: start.getTime(), end: end.getTime() }}),
      api.get('/phosphorus-data', { params: { start: start.getTime(), end: end.getTime() }}),
      api.get('/potassium-data', { params: { start: start.getTime(), end: end.getTime() }}),
      api.get('/light-data', { params: { start: start.getTime(), end: end.getTime() }})
    ])
    
    // 处理返回的数据
    const data = {
      temperature: tempData[tempData.length - 1]?.value,
      ph: phData[phData.length - 1]?.value,
      phosphorus: phosphorusData[phosphorusData.length - 1]?.value,
      potassium: potassiumData[potassiumData.length - 1]?.value,
      light: lightData[lightData.length - 1]?.value
    }
    
    return { 
      code: 200,
      message: "数据采集成功",
      data 
    }
  } catch (error) {
    console.error('数据采集失败:', error)
    throw error
  }
}

// 摄像头相关
export const getRecentPhotos = (deviceId, limit = 10, startTime, endTime) => {
  return api.get('/camera-data/recent', {
    params: { 
      deviceId, 
      limit,
      startTime: startTime ? startTime.getTime() : undefined,
      endTime: endTime ? endTime.getTime() : undefined
    }
  })
}

export const collectCameraData = () => {
  return api.post('/camera-data/collect')
}

// 视频监控相关
export const getCameraInfo = () => {
  return api.get('/api/camera-data/recent')
}

export const getCameraHistory = (startTime, endTime) => {
  return api.get('/api/camera-data/recent', {
    params: {
      startTime,
      endTime
    }
  })
}

// 视频捕获相关
export const captureImage = () => {
  return api.post('/camera-data/collect')
}

export const getLatestCapture = () => {
  return api.get('/camera/latest')
}

export const getCaptureHistory = (params) => {
  const { startTime, endTime, pageSize, pageNum } = params
  
  return api.get('/camera-data/history', {
    params: {
      startTime,
      endTime,
      pageSize: pageSize || 10,
      pageNum: pageNum || 1
    },
    headers: {
      'Accept': 'application/json',
      'Content-Type': 'application/json'
    },
    transformResponse: [
      data => {
        // 打印原始响应数据
        console.log('原始响应数据:', data)
        
        if (typeof data === 'string') {
          try {
            // 尝试直接解析
            return JSON.parse(data)
          } catch (e) {
            console.log('直接解析失败，尝试清理数据')
            try {
              // 查找第一个 { 和最后一个 }
              const start = data.indexOf('{')
              const end = data.lastIndexOf('}') + 1
              if (start !== -1 && end > start) {
                // 提取可能的JSON字符串
                const possibleJson = data.substring(start, end)
                console.log('提取的JSON字符串:', possibleJson)
                
                // 尝试解析提取的字符串
                const parsed = JSON.parse(possibleJson)
                console.log('解析结果:', parsed)
                
                // 如果解析成功并且包含所需的数据结构，返回它
                if (parsed.data || parsed.total) {
                  return parsed
                }
              }
            } catch (e2) {
              console.error('数据清理和解析失败:', e2)
            }
            
            // 如果所有尝试都失败了，返回一个空的结果结构
            return {
              data: [],
              total: 0
            }
          }
        }
        return data
      }
    ],
    validateStatus: function (status) {
      // 接受任何状态码，让响应拦截器来处理错误
      return true
    }
  }).catch(error => {
    console.error('请求失败:', error)
    if (error.response?.data) {
      console.log('错误响应数据:', error.response.data)
    }
    // 返回空结果而不是抛出错误
    return {
      data: [],
      total: 0
    }
  })
}

export const getCameraToken = () => {
  return api.get('/camera-data/token')
}

// 添加新的API方法
export const collectNewData = (greenhouseId) => {
  // 确保greenhouseId有值，默认使用'E-01'
  const id = greenhouseId || 'E-01'
  console.log('发送请求到:', `/api/soil-data/collect/${id}`)
  return api.get(`/api/soil-data/collect/${id}`)
}

export default api




